/**
* \file		Terrain.c
* \brief	Code des fonctions du module Terrain
* \details	C'est ici qu'est le code des accesseurs, mutateurs ainsi que
*		la fonction de test vérifant le bon fonctionnement du module
*		Terrain.
*		Une description de la structure Terrain est fournie à
*		la rubrique \link Terrain.h
*/

/* voir si on garde tous les includes */
#include "Terrain.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

/*========================== Gestion de la mémoire ==========================*/

void initTerrain(Terrain *pterrain, char *nom, char *representation)
{
   pterrain->nom = (char *)malloc((strlen(nom)+1)*sizeof(char));
   pterrain->representation = (char *)malloc((strlen(representation)+1)*sizeof(char));
   setNomTerrain(pterrain, nom);
   setRepresentationTerrain(pterrain, representation);
   setCultivableTerrain(pterrain, 0);
   setTraversableTerrain(pterrain, 0);
   setTerrainDeSurface(pterrain, 0);
}

Terrain creerTerrain(char *nom, char *representation)
{
   Terrain nouvTerr;
   initTerrain(&nouvTerr, nom, representation);

   return nouvTerr;
}

void libereTerrain(Terrain *pterrain)
{
   free(pterrain->nom);
   free(pterrain->representation);
   pterrain->nom = NULL;
   pterrain->representation = NULL;
   setCultivableTerrain(pterrain, 0);
   setTraversableTerrain(pterrain, 0);
   setTerrainDeSurface(pterrain, 0);
}

void detruireTerrain(Terrain *pterrain)
{
   libereTerrain(pterrain);
   pterrain = NULL;
}

/*============================= Accesseurs =============================*/

char *getNomTerrain(const Terrain *pterrain)
{
   char *nomTerr = pterrain->nom;
   return nomTerr;
}

char *getRepresentationTerrain(const Terrain *pterrain)
{
   char *reprTerr = pterrain->representation;
   return reprTerr;
}

char getCultivableTerrain(const Terrain *pterrain)
{
   char res = pterrain->cultivable;
   assert((res == 1)||(res == 0));
   return res;
}

char getTraversableTerrain(const Terrain *pterrain)
{
   char res = pterrain->traversableSiVide;
   assert((res == 1)||(res == 0));
   return res;
}

char getTerrainDeSurface(const Terrain *pterrain)
{
   char res = pterrain->terrainDeSurface;
   assert((res == 1)||(res == 0)||(res == 2));
   return res;
}

/*============================== Mutateurs ==============================*/

void setNomTerrain(Terrain *pterrain, char *nouvNom)
{
   free(pterrain->nom);
   pterrain->nom = (char *)malloc((strlen(nouvNom)+1)*sizeof(char));
   strcpy(pterrain->nom, nouvNom);
}

void setRepresentationTerrain(Terrain *pterrain, char *adresseImage)
{
   free(pterrain->representation);
   pterrain->representation = (char *)malloc((strlen(adresseImage)+1)*sizeof(char));
   strcpy(pterrain->representation, adresseImage);
}

void setCultivableTerrain(Terrain *pterrain, char valCultivable)
{
   pterrain->cultivable = valCultivable;
}

void setTraversableTerrain(Terrain *pterrain, char valTraversable)
{
   pterrain->traversableSiVide = valTraversable;
}

void setTerrainDeSurface(Terrain *pterrain, char valTerrainDeSurface)
{
   pterrain->terrainDeSurface = valTerrainDeSurface;
}

/*========================== Fonctions autres ==========================*/

char cmpTerrainNom(const Terrain *pterr1, const char *nomTerr)
{
   char res = 0;
   if(strcmp(getNomTerrain(pterr1), nomTerr) == 0)
	{
	   res = 1;
	}
   return res;
}

/*========================== Fonction de Test ==========================*/

void testTerrain()
{
   char testVar;
   char tab[][50] = {"test d'un nom très très long pour le terrain","essai", ",/\nsj yjnz", "Eléonore"};
   Terrain terrainTest;
   int i;
   Terrain tabTerr[4];

   printf("Test de Terrain\n");
   for(i=0; i<4;i++)
	{
	   terrainTest = creerTerrain(tab[i], tab[i]);
	   assert(!strcmp(terrainTest.nom, tab[i]));
	   assert(!strcmp(terrainTest.representation, tab[i]));
	   detruireTerrain(&terrainTest);
	}

   terrainTest = creerTerrain(tab[i-1], tab[i-1]);

   printf("\tCréation et initialisation du terrain \t\tOK\n");

   for(i=0; i<2; i++)
	{
	   setCultivableTerrain(&terrainTest, i);
	   assert(getCultivableTerrain(&terrainTest) == i);
	   setTraversableTerrain(&terrainTest, i);
	   assert(getTraversableTerrain(&terrainTest) == i);
	}

   for(i=0; i<=2; i++)
	{
	   setTerrainDeSurface(&terrainTest, i);
	   assert(getTerrainDeSurface(&terrainTest) == i);
	
	}

   for(i=0; i<4;i++)
	{
	   setNomTerrain(&terrainTest, tab[i]);
	   assert(!strcmp(getNomTerrain(&terrainTest), tab[i]));
	   setRepresentationTerrain(&terrainTest, tab[i]);
	   assert(!strcmp(getRepresentationTerrain(&terrainTest), tab[i]));
	}

   printf("\tAffectation et récupération de valeurs \t\tOK\n");

   testVar = getCultivableTerrain(&terrainTest);

   setCultivableTerrain(&terrainTest, 1);
   
   testVar = getCultivableTerrain(&terrainTest);
   assert(testVar == 1);

   printf("\tComparaison du nom d'un terrain et d'un nom\t");
   for (i=0; i<4; i++)
	{
	   tabTerr[i] = creerTerrain(tab[i], tab[i]);
	}

   for (i=0; i<4; i++)
	{
	   assert(cmpTerrainNom(&tabTerr[i],tab[i]) == 1);
	   assert(cmpTerrainNom(&tabTerr[i],tab[3-i]) == 0);
   	   detruireTerrain(&tabTerr[i]);
	}
   printf("OK\n\n");


   detruireTerrain(&terrainTest);
}
